#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
长尾关键词挖掘与分类系统 - 主程序入口

这是一个完整的长尾关键词挖掘、数据清洗、分类和可视化系统。
系统能够从多个数据源采集关键词，进行智能清洗，使用机器学习算法分类，
并生成丰富的可视化报告。

使用方法:
    python main.py [选项]

选项:
    --collect    执行数据采集
    --clean      执行数据清洗
    --classify   执行关键词分类
    --visualize  生成可视化图表
    --all        执行完整流程
    --config     指定配置文件路径
"""

import argparse
import sys
import os
import time
from datetime import datetime

# 添加src目录到Python路径
sys.path.insert(0, os.path.join(os.path.dirname(__file__), 'src'))

from src.utils import load_config, setup_logging, save_data, ensure_dir
from src.data_collector import KeywordCollector
from src.data_cleaner import KeywordCleaner
from src.classifier import KeywordClassifier
from src.visualizer import KeywordVisualizer
import pandas as pd
import logging


class KeywordMiningPipeline:
    """长尾关键词挖掘流水线"""
    
    def __init__(self, config_path: str = "config/config.yaml"):
        """
        初始化流水线
        
        Args:
            config_path: 配置文件路径
        """
        self.config = load_config(config_path)
        self.logger = setup_logging(self.config)
        
        # 初始化各个组件
        self.collector = KeywordCollector(self.config)
        self.cleaner = KeywordCleaner(self.config)
        self.classifier = KeywordClassifier(self.config)
        self.visualizer = KeywordVisualizer(self.config)
        
        # 确保目录存在
        for directory in ['data/raw', 'data/cleaned', 'data/results', 'logs']:
            ensure_dir(directory)
        
        self.logger.info("长尾关键词挖掘系统初始化完成")
    
    def run_data_collection(self) -> pd.DataFrame:
        """
        执行数据采集
        
        Returns:
            采集到的关键词DataFrame
        """
        self.logger.info("=" * 50)
        self.logger.info("开始数据采集阶段")
        self.logger.info("=" * 50)
        
        start_time = time.time()
        
        try:
            # 执行数据采集
            keywords_df = self.collector.collect_keywords()
            
            # 保存原始数据
            save_data(keywords_df, 'collected_keywords', ['csv'], 'data/raw')
            
            elapsed_time = time.time() - start_time
            self.logger.info(f"数据采集完成，用时 {elapsed_time:.2f} 秒")
            self.logger.info(f"共采集到 {len(keywords_df)} 个关键词")
            
            return keywords_df
            
        except Exception as e:
            self.logger.error(f"数据采集失败: {e}")
            raise
    
    def run_data_cleaning(self, input_df: pd.DataFrame = None) -> pd.DataFrame:
        """
        执行数据清洗
        
        Args:
            input_df: 输入数据DataFrame，如果为None则从文件读取
        
        Returns:
            清洗后的关键词DataFrame
        """
        self.logger.info("=" * 50)
        self.logger.info("开始数据清洗阶段")
        self.logger.info("=" * 50)
        
        start_time = time.time()
        
        try:
            # 读取数据
            if input_df is None:
                input_df = pd.read_csv('data/raw/collected_keywords.csv')
                self.logger.info(f"从文件读取到 {len(input_df)} 个原始关键词")
            
            # 执行数据清洗
            cleaned_df = self.cleaner.clean_keywords(input_df)
            
            # 生成清洗报告
            report = self.cleaner.generate_cleaning_report(input_df, cleaned_df)
            
            # 保存清洗后的数据
            save_data(cleaned_df, 'cleaned_keywords', ['csv'], 'data/cleaned')
            
            # 保存清洗报告
            import json
            with open('data/results/cleaning_report.json', 'w', encoding='utf-8') as f:
                json.dump(report, f, ensure_ascii=False, indent=2, default=str)
            
            elapsed_time = time.time() - start_time
            self.logger.info(f"数据清洗完成，用时 {elapsed_time:.2f} 秒")
            self.logger.info(f"清洗前: {report['original_count']} 个关键词")
            self.logger.info(f"清洗后: {report['cleaned_count']} 个关键词")
            self.logger.info(f"清洗率: {report['removal_rate']:.2f}%")
            
            return cleaned_df
            
        except Exception as e:
            self.logger.error(f"数据清洗失败: {e}")
            raise
    
    def run_classification(self, input_df: pd.DataFrame = None) -> pd.DataFrame:
        """
        执行关键词分类
        
        Args:
            input_df: 输入数据DataFrame，如果为None则从文件读取
        
        Returns:
            分类后的关键词DataFrame
        """
        self.logger.info("=" * 50)
        self.logger.info("开始关键词分类阶段")
        self.logger.info("=" * 50)
        
        start_time = time.time()
        
        try:
            # 读取数据
            if input_df is None:
                input_df = pd.read_csv('data/cleaned/cleaned_keywords.csv')
                self.logger.info(f"从文件读取到 {len(input_df)} 个清洗后的关键词")
            
            # 执行关键词分类
            classified_df = self.classifier.classify_keywords(input_df)
            
            # 生成分类报告
            report = self.classifier.generate_classification_report(classified_df)
            
            # 保存分类结果
            output_config = self.config.get('output', {})
            save_data(
                classified_df,
                'classified_keywords',
                output_config.get('formats', ['csv', 'xlsx']),
                output_config.get('save_path', 'data/results')
            )
            
            # 保存分类报告
            import json
            with open('data/results/classification_report.json', 'w', encoding='utf-8') as f:
                json.dump(report, f, ensure_ascii=False, indent=2, default=str)
            
            elapsed_time = time.time() - start_time
            self.logger.info(f"关键词分类完成，用时 {elapsed_time:.2f} 秒")
            self.logger.info(f"总关键词数: {report['total_keywords']}")
            self.logger.info(f"聚类数量: {report['unique_clusters']}")
            self.logger.info(f"分类数量: {report['unique_ml_categories']}")
            self.logger.info(f"平均置信度: {report['avg_confidence']:.4f}")
            
            return classified_df
            
        except Exception as e:
            self.logger.error(f"关键词分类失败: {e}")
            raise
    
    def run_visualization(self, input_df: pd.DataFrame = None) -> None:
        """
        执行数据可视化
        
        Args:
            input_df: 输入数据DataFrame，如果为None则从文件读取
        """
        self.logger.info("=" * 50)
        self.logger.info("开始数据可视化阶段")
        self.logger.info("=" * 50)
        
        start_time = time.time()
        
        try:
            # 读取数据
            if input_df is None:
                input_df = pd.read_csv('data/results/classified_keywords.csv')
                self.logger.info(f"从文件读取到 {len(input_df)} 个分类后的关键词")
            
            # 生成所有可视化
            self.visualizer.create_all_visualizations(input_df)
            
            # 生成可视化报告
            report = self.visualizer.generate_visualization_report(input_df)
            
            elapsed_time = time.time() - start_time
            self.logger.info(f"数据可视化完成，用时 {elapsed_time:.2f} 秒")
            self.logger.info("可视化文件已保存到 data/results/visualizations/ 目录")
            
        except Exception as e:
            self.logger.error(f"数据可视化失败: {e}")
            raise
    
    def run_full_pipeline(self) -> None:
        """
        执行完整的挖掘流水线
        """
        self.logger.info("🚀 开始执行完整的长尾关键词挖掘流水线")
        self.logger.info(f"开始时间: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
        
        pipeline_start_time = time.time()
        
        try:
            # 1. 数据采集
            collected_df = self.run_data_collection()
            
            # 2. 数据清洗
            cleaned_df = self.run_data_cleaning(collected_df)
            
            # 3. 关键词分类
            classified_df = self.run_classification(cleaned_df)
            
            # 4. 数据可视化
            self.run_visualization(classified_df)
            
            # 计算总用时
            total_time = time.time() - pipeline_start_time
            
            # 生成最终报告
            final_report = {
                'pipeline_info': {
                    'start_time': datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
                    'total_time': f"{total_time:.2f} 秒",
                    'status': 'success'
                },
                'data_statistics': {
                    'collected_keywords': len(collected_df),
                    'cleaned_keywords': len(cleaned_df),
                    'classified_keywords': len(classified_df),
                    'cleaning_rate': (len(collected_df) - len(cleaned_df)) / len(collected_df) * 100
                },
                'output_files': {
                    'raw_data': 'data/raw/collected_keywords.csv',
                    'cleaned_data': 'data/cleaned/cleaned_keywords.csv',
                    'classified_data': 'data/results/classified_keywords.csv',
                    'visualizations': 'data/results/visualizations/',
                    'reports': ['data/results/cleaning_report.json', 
                              'data/results/classification_report.json']
                }
            }
            
            # 保存最终报告
            import json
            with open('data/results/final_report.json', 'w', encoding='utf-8') as f:
                json.dump(final_report, f, ensure_ascii=False, indent=2, default=str)
            
            self.logger.info("=" * 60)
            self.logger.info("🎉 长尾关键词挖掘流水线执行完成！")
            self.logger.info("=" * 60)
            self.logger.info(f"总用时: {total_time:.2f} 秒")
            self.logger.info(f"采集关键词: {len(collected_df)} 个")
            self.logger.info(f"清洗关键词: {len(cleaned_df)} 个")
            self.logger.info(f"最终关键词: {len(classified_df)} 个")
            self.logger.info("所有结果文件已保存到 data/ 目录")
            self.logger.info("请查看 data/results/visualizations/ 目录中的可视化图表")
            
        except Exception as e:
            self.logger.error(f"流水线执行失败: {e}")
            raise


def main():
    """主函数"""
    parser = argparse.ArgumentParser(
        description="长尾关键词挖掘与分类系统",
        formatter_class=argparse.RawDescriptionHelpFormatter,
        epilog="""
示例:
    python main.py --all                    # 执行完整流程
    python main.py --collect               # 仅执行数据采集
    python main.py --clean                 # 仅执行数据清洗
    python main.py --classify              # 仅执行关键词分类
    python main.py --visualize             # 仅生成可视化
    python main.py --config custom.yaml   # 使用自定义配置文件
        """
    )
    
    parser.add_argument('--collect', action='store_true', help='执行数据采集')
    parser.add_argument('--clean', action='store_true', help='执行数据清洗')
    parser.add_argument('--classify', action='store_true', help='执行关键词分类')
    parser.add_argument('--visualize', action='store_true', help='生成可视化图表')
    parser.add_argument('--all', action='store_true', help='执行完整流程')
    parser.add_argument('--config', type=str, default='config/config.yaml', 
                       help='配置文件路径 (默认: config/config.yaml)')
    
    args = parser.parse_args()
    
    # 如果没有指定任何参数，默认执行完整流程
    if not any([args.collect, args.clean, args.classify, args.visualize, args.all]):
        args.all = True
    
    try:
        # 初始化流水线
        pipeline = KeywordMiningPipeline(args.config)
        
        # 执行相应的操作
        if args.all:
            pipeline.run_full_pipeline()
        else:
            if args.collect:
                pipeline.run_data_collection()
            
            if args.clean:
                pipeline.run_data_cleaning()
            
            if args.classify:
                pipeline.run_classification()
            
            if args.visualize:
                pipeline.run_visualization()
        
        print("\n✅ 程序执行成功！")
        
    except KeyboardInterrupt:
        print("\n⚠️  程序被用户中断")
        sys.exit(1)
    except Exception as e:
        print(f"\n❌ 程序执行失败: {e}")
        sys.exit(1)


if __name__ == "__main__":
    main()
